/**
 * 用户业务逻辑
 */
const { testHelper } = require('../../../helpers/index.js');

/**
 * 角色定义
 */
const ROLES = {
  // 基础角色
  ADMIN: 'admin',               // 管理员
  PROJECT_MANAGER: 'pm',        // 项目经理
  DEVELOPER: 'dev',             // 开发人员
  TESTER: 'test',               // 测试人员
  GUEST: 'guest',               // 访客
  
  // 研发流程特定角色
  RESEARCH_MANAGER: 'research_manager',       // 研发经理
  DIRECTOR: 'director',                       // 董事长
  HARDWARE_ENGINEER: 'hardware_engineer',     // 硬件工程师
  SOFTWARE_ENGINEER: 'software_engineer',     // 软件工程师
  SAMPLE_GROUP: 'sample_group',               // 样品组
  PROCUREMENT: 'procurement',                 // 采购人员
  DOC_CONTROLLER: 'doc_controller',           // 文控
  WAREHOUSE: 'warehouse',                     // 仓库人员
  RECEPTIONIST: 'receptionist',               // 前台人员
  BUSINESS: 'business',                       // 业务人员
  SECRETARY: 'secretary',                     // 文秘人员
  PRODUCTION_SUPERVISOR: 'production_supervisor', // 生产主管
  PE: 'pe',                                   // PE工程师
  RESEARCH_MEMBER: 'research_member'          // 研发成员
};

// 检查testHelper是否已正确加载
function isDebugMode() {
  try {
    if (testHelper && testHelper.isDebugMode) {
      return testHelper.isDebugMode();
    }
    return false;
  } catch (err) {
    console.error('[用户业务] 调试模式检查失败:', err);
    return false;
  }
}

// 获取当前角色的安全包装
function getCurrentRole() {
  try {
    if (testHelper && testHelper.getCurrentRole) {
      return testHelper.getCurrentRole();
    }
    return null;
  } catch (err) {
    console.error('[用户业务] 获取当前角色失败:', err);
    return null;
  }
}

// 检查是否有角色的安全包装
function hasRoleHelper(role) {
  try {
    if (testHelper && testHelper.hasRole) {
      return testHelper.hasRole(role);
    }
    return false;
  } catch (err) {
    console.error('[用户业务] 角色检查失败:', err);
    return false;
  }
}

// 检查是否有任意角色的安全包装
function hasAnyRoleHelper(roles) {
  try {
    if (testHelper && testHelper.hasAnyRole) {
      return testHelper.hasAnyRole(roles);
    }
    return false;
  } catch (err) {
    console.error('[用户业务] 角色检查失败:', err);
    return false;
  }
}

/**
 * 检查用户是否有指定角色
 * @param {Object} user 用户信息
 * @param {String} role 角色
 * @returns {Boolean} 是否有角色
 */
function hasRole(user, role) {
  // 测试模式：直接模拟拥有指定角色
  if (isDebugMode()) {
    return hasRoleHelper(role);
  }
  
  // 正常逻辑
  if (!user || !user.USER_ROLES) return false;
  
  return user.USER_ROLES.includes(role);
}

/**
 * 检查用户是否有任意一个指定角色
 * @param {Object} user 用户信息
 * @param {Array} roles 角色数组
 * @returns {Boolean} 是否有任意一个角色
 */
function hasAnyRole(user, roles) {
  if (!Array.isArray(roles) || roles.length === 0) return false;
  
  // 测试模式
  if (isDebugMode()) {
    return hasAnyRoleHelper(roles);
  }
  
  // 正常逻辑
  if (!user || !user.USER_ROLES) return false;
  
  return roles.some(role => user.USER_ROLES.includes(role));
}

/**
 * 检查用户是否为管理员
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为管理员
 */
function isAdmin(user) {
  // 测试模式：直接检查是否为管理员角色
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.ADMIN;
  }
  
  return hasRole(user, ROLES.ADMIN);
}

/**
 * 检查用户是否为项目经理
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为项目经理
 */
function isProjectManager(user) {
  // 测试模式：直接检查是否为项目经理角色
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.PROJECT_MANAGER;
  }
  
  return hasRole(user, ROLES.PROJECT_MANAGER);
}

/**
 * 检查用户是否为研发经理
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为研发经理
 */
function isResearchManager(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.RESEARCH_MANAGER;
  }
  
  return hasRole(user, ROLES.RESEARCH_MANAGER);
}

/**
 * 检查用户是否为董事长
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为董事长
 */
function isDirector(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.DIRECTOR;
  }
  
  return hasRole(user, ROLES.DIRECTOR);
}

/**
 * 检查用户是否为硬件工程师
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为硬件工程师
 */
function isHardwareEngineer(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.HARDWARE_ENGINEER;
  }
  
  return hasRole(user, ROLES.HARDWARE_ENGINEER);
}

/**
 * 检查用户是否为软件工程师
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为软件工程师
 */
function isSoftwareEngineer(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.SOFTWARE_ENGINEER;
  }
  
  return hasRole(user, ROLES.SOFTWARE_ENGINEER);
}

/**
 * 检查用户是否为开发人员
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为开发人员
 */
function isDeveloper(user) {
  // 测试模式：直接检查是否为开发人员角色
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.DEVELOPER;
  }
  
  return hasRole(user, ROLES.DEVELOPER);
}

/**
 * 检查用户是否为测试人员
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为测试人员
 */
function isTester(user) {
  // 测试模式：直接检查是否为测试人员角色
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.TESTER;
  }
  
  return hasRole(user, ROLES.TESTER);
}

/**
 * 检查用户是否为业务人员
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为业务人员
 */
function isBusinessPerson(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.BUSINESS;
  }
  
  return hasRole(user, ROLES.BUSINESS);
}

/**
 * 检查用户是否为文控
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为文控
 */
function isDocController(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.DOC_CONTROLLER;
  }
  
  return hasRole(user, ROLES.DOC_CONTROLLER);
}

/**
 * 检查用户是否为仓库人员
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为仓库人员
 */
function isWarehousePerson(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.WAREHOUSE;
  }
  
  return hasRole(user, ROLES.WAREHOUSE);
}

/**
 * 检查用户是否为生产主管
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为生产主管
 */
function isProductionSupervisor(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.PRODUCTION_SUPERVISOR;
  }
  
  return hasRole(user, ROLES.PRODUCTION_SUPERVISOR);
}

/**
 * 检查用户是否为PE工程师
 * @param {Object} user 用户信息
 * @returns {Boolean} 是否为PE工程师
 */
function isPEEngineer(user) {
  // 测试模式
  if (isDebugMode()) {
    return getCurrentRole() === ROLES.PE;
  }
  
  return hasRole(user, ROLES.PE);
}

/**
 * 检查用户是否为项目成员
 * @param {Object} user 用户信息
 * @param {Object} project 项目信息
 * @returns {Boolean} 是否为项目成员
 */
function isProjectMember(user, project) {
  // 测试模式：模拟项目成员
  if (isDebugMode()) {
    // 管理员、项目经理、开发人员和测试人员都视为项目成员
    return hasAnyRoleHelper([ROLES.ADMIN, ROLES.PROJECT_MANAGER, ROLES.DEVELOPER, ROLES.TESTER]);
  }
  
  if (!user || !project || !project.members) return false;
  
  return project.members.some(member => member.USER_ID === user.USER_ID);
}

/**
 * 检查用户是否为项目负责人
 * @param {Object} user 用户信息
 * @param {Object} project 项目信息
 * @returns {Boolean} 是否为项目负责人
 */
function isProjectOwner(user, project) {
  // 测试模式：模拟项目负责人
  if (isDebugMode()) {
    // 管理员和项目经理视为项目负责人
    return hasAnyRoleHelper([ROLES.ADMIN, ROLES.PROJECT_MANAGER]);
  }
  
  if (!user || !project) return false;
  
  return user.USER_ID === project.PROJECT_USER_ID;
}

module.exports = {
  ROLES,
  hasRole,
  hasAnyRole,
  isAdmin,
  isProjectManager,
  isResearchManager,
  isDirector,
  isHardwareEngineer,
  isSoftwareEngineer,
  isDeveloper,
  isTester,
  isBusinessPerson,
  isDocController,
  isWarehousePerson,
  isProductionSupervisor,
  isPEEngineer,
  isProjectMember,
  isProjectOwner
}; 